package com.itheima.d2_buffered_stream;

import java.io.*;

/**
    目标：观察原始流和缓冲流的性能。

 测试用例：
 分别使用原始的字节流，以及字节缓冲流复制一个很大视频。
 测试步骤：
 1.使用低级的字节流按照一个一个字节的形式复制文件。
 2.使用低级的字节流按照字节数组的形式复制文件。
 3.使用高级的缓冲字节流按照一个一个字节的形式复制文件。
 4.使用高级的缓冲字节流按照字节数组的形式复制文件。

 */
public class TimeTest4 {
    // 复制的视频路径
    private static final String SRC_FILE = "D:\\Idea\\resource\\ShiPingFuZhi1\\video.mp4";
    // 复制到哪个目的地
    private static final String DEST_FILE = "D:\\Idea\\resource\\ShiPingFuZhi2\\";

    public static void main(String[] args) {
         //copy01(); // 低级字节流一个一个字节的赋值，慢的简直让人无法忍受，直接淘汰！
        copy02();// 低级的字节流流按照一个一个字节数组的形式复制，速度较慢！
         //copy03(); // 缓冲流按照一个一个字节的形式复制，速度较慢,直接淘汰！
        copy04(); // 缓冲流按照一个一个字节数组的形式复制，速度极快，推荐使用！

        /*
        大家都知道缓冲流是因为内部有一个8kb的缓冲池，那么假设低级字节流按照8kb的字节数组复制呢？
        然后再把高级的缓冲流也按照8kb的字节数组复制对比一下
        注意：改的这个字节数组是指内存中的字节数组，和高级缓冲流里面的缓冲池8kb字节数组无关

        这个1024*32意思就是把高级缓冲流里面的缓冲池字节数组，改为32kb的
       BufferedInputStream bis = new BufferedInputStream(is,1024*32);

         */
    }


    /**
     *  用低级字节输入输出流，一个一个字节复制所花的时间：
     */
    private static void copy01() {
        //拿到系统的当前时间
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "1.mp4");
        ){

            int b;
            while ((b = is.read()) != -1){
                os.write(b);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        //默认的是毫秒形式，所以要除一千
        System.out.println("低级字节流一个一个字节复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    /**
     *    用低级字节输入输出流，但是用1kb大小的字节数组复制：
     */
    private static void copy02() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                OutputStream os = new FileOutputStream(DEST_FILE + "2.mp4");
        ){
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("低级字节流使用字节数组复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }

    /**
     * 用高级的字节缓冲输入输出流按照一个一个字节复制：
     */
    private static void copy03() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(DEST_FILE + "3.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ){

            int b;
            while ((b = bis.read()) != -1){
                bos.write(b);
            }

        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流一个一个字节复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }


    /**
     * 用高级的字节缓冲输入输出流按照1kb的字节数组复制：
     */
    private static void copy04() {
        long startTime = System.currentTimeMillis();
        try (
                InputStream is = new FileInputStream(SRC_FILE);
                BufferedInputStream bis = new BufferedInputStream(is);
                OutputStream os = new FileOutputStream(DEST_FILE + "4.mp4");
                BufferedOutputStream bos = new BufferedOutputStream(os);
        ){
            byte[] buffer = new byte[1024]; //1kb
            int len;
            while ((len = bis.read(buffer)) != -1){
                bos.write(buffer, 0, len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        long endTime = System.currentTimeMillis();
        System.out.println("缓冲流使用字节数组复制耗时：" + (endTime - startTime) / 1000.0 + "s");
    }
}










